home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Tech Arsenal 1
/
Tech Arsenal (Arsenal Computer).ISO
/
tek-02
/
vdl020d.zip
/
VSDLPLOW.DOC
< prev
next >
Wrap
Text File
|
1993-04-14
|
66KB
|
3,136 lines
(*=================== S D L P L O W U N I T =====================
= =
= REVISION 2.0 07/10/92 J.R. TAYLOR =
= =
==========================================================================
= =
= SDLP Management Library for TP V:4.0, 5.0, 5.5, 6.0 =
= =
= Written By Jonathan Robert Taylor =
= =
= This code is the property of Columbia Data Products, Inc. =
= It may be distributed and used outside CDP so long as this header =
= remains intact and unmodified, and as long as it is used with a =
= licensed Standard Device Level Protocol Kernel. =
= =
= Copyright 1989-1992 Columbia Data Products =
= ALL RIGHTS RESERVED =
= =
==========================================================================
= =
= Revision History Procedures changed; overall purpose of change.=
= Procedure specific revision notes below. =
= Reverse chronological order. =
= ---------------------------------------------------------------------- =
= date initials change description =
= ---------------------------------------------------------------------- =
= =
= 03-12-93 lpg Added Source Documentation =
= =
= 03-12-93 lpg Added: MakeUNum =
= =
= 07-29-92 jrt Modified to use either SDLP or SAL, took out =
= code to use HAC Manager directly, resaved as =
= VSDLPLOW. =
= =
= 07-10-92 jrt Modified to use either SDLP BIOS or Hac Manager =
= 07-16-90 jrt Started =
= =
==========================================================================
= =
= Caveats =
= ---------------------------------------------------------------------- =
= date initals description =
= ---------------------------------------------------------------------- =
= =
= 07-10-92 jrt Many functions are not yet implemented in HAC =
= manager mode. =
= =
= Error checking and retries in HM mode are not =
= fully completed. =
= =
==========================================================================
*)
Unit VSDLPLOW;
{-------------------------------------------------------------------------}
{ UNIT SDLPLow }
{-------------------------------------------------------------------------}
{ PURPOSE: Low-Level SDLP Library. This unit provides all the low-level }
{ SDLP function calls. No longer requiring the programmer to keep track }
{ of what to load where, but now simply know the call name and it's few }
{ parameters. }
{ SOURCE : JR Taylor }
{-------------------------------------------------------------------------}
Interface {================================================================}
Uses
VTypes,
VSal,
VSalHigh,
DOS;
Const
SL_UseSDLP = 1;
SL_UseSAL = 16;
{ SHOULD HAVE DEVICE TYPE CONSTANTS! }
{ The following are made up because I don't recall the true numbers }
{-----------------------}
{ Device Type Constants }
{-----------------------}
cDASD = 0;
cRemov = 1;
cSeq = 3;
cCDROM = 5;
cPrint = 8;
cProc = 9;
(*
DEV_DASD = $00;
DEV_Sequential = $01;
DEV_Printer = $02;
DEV_Processor = $03;
DEV_WORM = $04;
DEV_CDROM = $05;
DEV_Scanner = $06;
DEV_Optical = $07;
DEV_Changer = $08;
DEV_Comm = $09;
DEV_Unknown = $1F;
*)
{----------------------}
{ Sequential Constants }
{----------------------}
cBlocks = 0;
cFileMarks = 1;
cSetMarks = 3;
Type
Terror = word;
Var
SDLPMethod : BYTE;
SDLPSalHandle : THandle;
Function SDLP_Installed : BOOLEAN;
Procedure SDLP_SysIdent( Var VerNum : BYTE;
Var RamRes : BOOLEAN;
Var NumHAC : BYTE;
Var ErrCode : BYTE );
Function SDLP_GetNumHacs : BYTE;
Function MakeUNum( HAC : BYTE;
Tgt : BYTE;
LUN : BYTE ) : BYTE;
Procedure SDLP_Read( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
Procedure SDLP_Write( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
Procedure SDLP_GetDevInfo( UNum : BYTE;
GetType : BOOLEAN;
GetSize : BOOLEAN;
Var NumBlock : LONGINT;
Var BlkSize : WORD;
Var DevType : BYTE;
Var ErrCode : BYTE );
Procedure SDLP_ReadyUnit( Unum : BYTE;
SecsToWait : BYTE;
Var ErrCode : BYTE );
Procedure SDLP_FormatUnit( Unum : BYTE;
InterLv : BYTE;
Var ErrCode : BYTE );
Procedure SDLP_Rewind( Unum : BYTE;
Var ErrCode : BYTE );
Procedure SDLP_Erase( Unum : BYTE;
RewFirst : BOOLEAN;
Var ErrCode : BYTE );
Procedure SDLP_WrFileMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Procedure SDLP_Space( Unum : BYTE;
BlksToSpc : LONGINT;
SpaceType : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Procedure SDLP_LockUnlock( Unum : BYTE;
Lock : BOOLEAN;
Var ErrCode : BYTE );
Procedure SDLP_LoadUnload( Unum : BYTE;
Load : BOOLEAN;
Var ErrCode : BYTE );
Procedure SDLP_Retension( UNum : BYTE;
Var ErrCode : BYTE );
Procedure SDLP_SetBlockSize( Unum : BYTE;
BlockSize : WORD;
Var ErrCode : BYTE );
Procedure SDLP_WrSetMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Procedure SDLP_SetSCSIXHac( HAC : INTEGER);
Procedure SDLP_GetSCSIXHac( Var Hac : INTEGER;
Var Err : BYTE );
Function OutSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ) : WORD;
Function InSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ) : WORD;
Function InSCSI_ReqSense( SUnit : BYTE;
Buff : Pointer;
ReqSenseLen : BYTE ) : WORD;
Function GetBus( SDLPUnit : BYTE ) : BYTE;
Function GetTar( SDLPUnit : BYTE ) : BYTE;
Function GetLun( SDLPUnit : BYTE ) : BYTE;
Implementation {===========================================================}
Var
UseSAL : BOOLEAN;
ExecSCSIHac : BYTE;
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function GetBus( SDLPUnit : BYTE ) : BYTE;
[PARAMETERS]
SDLPUnit SDLP Unit Number (Contains HAC, TGT, & LUN)
[RETURNS]
The Host Adapter Channel Portion of the SDLP Unit Number
[DESCRIPTION]
Extracts the Host Adapter Channel Portion of the SDLP Unit Number.
("Host Adapter Channel" and "Bus" are considered synonomous here).
An SDLP Unit Number is Bitmapped as Follows:
Bits Name ( hhtt tlll )
---- ----
7-6 Host Adapter
5-3 Target ID
2-0 Logical Unit Number (Generally Zero)
[SEE-ALSO]
MakeUNum
GetTar
GetLun
[EXAMPLE]
Uses VGen;
VAR
UNum : BYTE;
BEGIN
UNum := BinToByte( '01101011' );
WriteLn( 'The HAC Number in this Unit Number is ', GetBus( UNum ) );
{ Displays the Number 1 }
END;
-*)
Function GetBus( SDLPUnit : BYTE ) : BYTE;
BEGIN
GetBus := (SDLPUnit SHR 6) And $3;
END; { GetBus }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function GetTgt( SDLPUnit : BYTE ) : BYTE;
[PARAMETERS]
SDLPUnit SDLP Unit Number (Contains HAC, TGT, & LUN)
[RETURNS]
The Target ID Portion of the SDLP Unit Number
[DESCRIPTION]
Extracts the Target ID Portion of the SDLP Unit Number. In General,
this can be consider the Device Number, unless this Device is actually
an adapter to another series of Devices (in which case LUN becomes
valid).
An SDLP Unit Number is Bitmapped as Follows:
Bits Name ( hhtt tlll )
---- ----
7-6 Host Adapter
5-3 Target ID
2-0 Logical Unit Number (Generally Zero)
[SEE-ALSO]
MakeUNum
GetBus
GetLun
[EXAMPLE]
Uses VGen;
VAR
UNum : BYTE;
BEGIN
UNum := BinToByte( '01101011' );
WriteLn( 'The Target ID Number in this Unit Number is ', GetTgt( UNum ) );
{ Displays the Number 5 }
END;
-*)
Function GetTar( SDLPUnit : BYTE ) : BYTE;
BEGIN
GetTar := (SDLPUnit SHR 3) and $07;
END; { GetTgt }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function GetLUN( SDLPUnit : BYTE ) : BYTE;
[PARAMETERS]
SDLPUnit SDLP Unit Number (Contains HAC, TGT, & LUN)
[RETURNS]
The Logical Unit Number (LUN) Portion of the SDLP Unit Number
[DESCRIPTION]
Extracts the Logical Unit Number (LUN) Portion of the SDLP Unit Number.
In General, the Target ID can be considered the Device Number, unless
this Device is actually an adapter to another series of Devices (which
is when the LUN becomes valid).
An SDLP Unit Number is Bitmapped as Follows:
Bits Name ( hhtt tlll )
---- ----
7-6 Host Adapter
5-3 Target ID
2-0 Logical Unit Number (Generally Zero)
[SEE-ALSO]
MakeUNum
GetBus
GetTgt
[EXAMPLE]
Uses VGen;
VAR
UNum : BYTE;
BEGIN
UNum := BinToByte( '01101011' );
WriteLn( 'The LUN Number in this Unit Number is ', GetLUN( UNum ) );
{ Displays the Number 3 }
END;
-*)
Function GetLun( SDLPUnit : BYTE ) : BYTE;
BEGIN
GetLun := SDLPUnit And $07;
END; { GetLun }
{────────────────────────────────────────────────────────────────────────────}
Function ErrorConvert( Err : TError ) : WORD;
BEGIN
Case Err Of
sSalxsOK : ErrorConvert := 0;
Else ErrorConvert := 1;
END; { Case Err }
END; { ErrorConvert }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_SysIdent( Var VerNum : BYTE;
Var RamRes : BOOLEAN;
Var NumHAC : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
VerNum VAR Returned SDLP Version Number
RamRes VAR Returned Is SDLP RAM Resident? (NO=ROM Resident)
NumHAC VAR Returned Number of Host Adapters Detected
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [VerNum] SDLP Version Number)
(VAR : [RamRes] Is SDLP RAM Resident?)
(VAR : [NumHAC] Number of Host Adapters Detected)
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Initialization command and returns the operation resutls.
The System configuration is returned in the VARs provided by the caller.
[SEE-ALSO]
SDLP_Installed
SDLP_GetNumHacs
[EXAMPLE]
Uses VGen;
VAR
RamRes : BOOLEAN;
VerNum,
NumHac,
ErrCode : BYTE;
BEGIN
SDLP_SysIdent( VerNum, RamRes, NumHac, ErrCode );
WriteLn( 'SDLP Version Number : ', ByteToHex( VerNum ) );
WriteLn( 'SDLP Ram Resident : ', RamRes );
WriteLn( 'Number of HACs on System : ', NumHac );
WriteLn( 'Operation Error Code : ', ByteToHex( ErrCode ) );
END;
-*)
Procedure SDLP_SysIdent( Var VerNum : BYTE;
Var RamRes : BOOLEAN;
Var NumHAC : BYTE;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If (UseSAL) Then
BEGIN
{ check if SAL installed }
VerNum := $20;
RamRes := TRUE;
NumHAC := 1;
ErrCode := 0;
END { If UseSAL }
ELSE
BEGIN
R.AH:=1;
R.AL:=0;
R.SI:=$6A6A;
Intr($11,R);
VerNum:=R.AH;
If R.AL=0 Then
RamRes:=TRUE
ELSE
RamRes:=FALSE;
NumHAC:=R.CL;
If R.DI=$6A6A Then
ErrCode:=0
Else
ErrCode:=$FF;
END; { If UseSAL / else }
END; { SDLP_SysIdent }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function SDLP_GetNumHacs : BYTE;
[PARAMETERS]
(None)
[RETURNS]
Number of Host Adapters Detected
[DESCRIPTION]
Attempts to Detect the Number of Host Adapters Attached tothe System
and returns the results.
[SEE-ALSO]
SDLP_Installed
SDLP_SysIdent
[EXAMPLE]
BEGIN
WriteLn( 'Number of Host Adapter Channels on This System is ',
SDLP_GetNumHacs );
END;
-*)
Function SDLP_GetNumHacs : BYTE;
Var
VerNum : BYTE;
RamRes : BOOLEAN;
NumHaC : BYTE;
ErrB : BYTE;
BEGIN
SDLP_SysIdent( VerNum, RamRes, NumHac, ErrB );
If ErrB=0 Then
SDLP_GetNumHacs := NumHac
Else
SDLP_GetNumHacs := 0;
END; { SDLP_GetNumHacs }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function SDLP_Installed : BOOLEAN;
[PARAMETERS]
(None)
[RETURNS]
Whether SDLP is Currently Installed
[DESCRIPTION]
Checks to see if SDLP is installed or not and returns the results.
[SEE-ALSO]
SDLP_SysIdent
SDLP_GetNumHacs
[EXAMPLE]
BEGIN
If SDLP_Installed Then
WriteLn( 'SDLP is Currently Installed' )
Else
WriteLn( 'SDKP is NOT Installed' );
END;
-*)
Function SDLP_Installed : BOOLEAN;
Function RealSDLPInstalled : BOOLEAN;
Var
R : REGISTERS;
BEGIN
R.AH:=1;
R.AL:=0;
R.SI:=$6A6A;
Intr($11,R);
IF R.DI=$6A6A Then
RealSDLPInstalled:=TRUE
Else
RealSDLPInstalled:=FALSE;
END; { RealSDLPInstalled }
BEGIN { SDLP_Installed }
Case SDLPMethod Of
SL_UseSDLP:
BEGIN
If RealSDLPInstalled Then
BEGIN
UseSAL := FALSE;
SDLP_Installed := TRUE;
END { If RealSDLPInstalled }
ELSE
BEGIN
UseSAL := TRUE;
{ do we verify installation somehow? }
END; { If RealSDLPInstalled / Else }
END; { Case SL_UseSDLP }
{-------------------------}
SL_UseSAL:
BEGIN
UseSAL := TRUE;
SDLP_Installed := TRUE; { What to do here? }
END; { Case SL_UseSAL }
Else
{ unkown SDLP method }
SDLP_Installed := False;
END; { Case SDLPMethod }
END; { SDLP_Installed }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function MakeUNum( HAC : BYTE;
Tgt : BYTE;
LUN : BYTE ) : BYTE;
[PARAMETERS]
HAC Host Adapter Bus
Tgt Device Target ID
LUN Logical Unit Number (usually Zero)
[RETURNS]
Created New SDLP Unit Number
[DESCRIPTION]
Creates a New SDLP Unit Number from the Provided Data.
[SEE-ALSO]
GetBus
GetTgt
GetLun
[EXAMPLE]
VAR
Buff : ARRAY[1..2048] of BYTE;
Err,
Res : BYTE;
BEGIN
SDLP_Read( MakeUNum( 1, 3, 0 ),
Addr( Buff ),
4,
0,
Err,
Res );
{ Reads from Device at HAC 1, Target ID 3, LUN 0 }
END;
-*)
Function MakeUNum( HAC : BYTE;
Tgt : BYTE;
LUN : BYTE ) : BYTE;
BEGIN
MakeUNum := (HAC AND $03 SHL 6) OR
(Tgt AND $07 SHL 3) OR
(LUN AND $07);
END; { MakeUNum }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Read( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
BuffAddr Pointer to Data Buffer
BlkCount Number of Blocks to Read
StartSec Block Number to Start Read from
ErrCode VAR Returned SDLP Error Code
Residue VAR Returned Number of Blocks Unread
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
(VAR : [Residue] Number of Blocks Unread)
[DESCRIPTION]
Executes an SDLP Read block command and returns the operation results.
Supported Device Types:
DASD
Removable DASD
Sequential
CDROM
[SEE-ALSO]
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_FormatUnit
SDLP_LockUnlock
[EXAMPLE]
VAR
Buff : ARRAY[1..2048] of BYTE
Err,
Res : BYTE;
BEGIN
SDLP_Read( MakeUNum( 0, 5, 0 ),
Addr( Buff ),
2,
8,
Err,
Res );
{ Reads 2 Blocks Starting at Block 8 from Target ID 5 }
END;
-*)
Procedure SDLP_Read( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
Var
Err : TError;
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
Err := SAL_S2DasdRead( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
If Err <> sSalxsOK Then
BEGIN
Err := SAL_S2DasdRead( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
END; { If Err }
If Err <> sSalxsOK Then
BEGIN
Err := SAL_S2DasdRead( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
END; { If Err }
ErrCode := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
R.AH:=2;
R.AL:=Unum;
R.ES:=Seg(BuffAddr^);
R.BX:=Ofs(BuffAddr^);
R.CL:=BlkCount;
R.CH:=StartSec DIV 65536;
R.DX:=StartSec MOD 65536;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
ErrCode:=R.AL;
Residue:=R.CL;
END { If Odd }
ELSE
BEGIN
ErrCode:=0;
Residue:=0;
END; { If Odd / Else }
END; { If UseSAL / Else }
END; { SDLP_Read }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Write( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
[PARAMETERS]
Unum SDLP Unit Number
BuffAddr Pointer to Data Buffer
BlkCount Number of Blocks to Write
StartSec Starting Block Number
ErrCode VAR Returned SDLP Error Code
Residue VAR Returned Number of Blocks Unwritten
[RETURNS]
(None)
[DESCRIPTION]
Executes an SDLP Write command and returns the operation results.
Supported Device Types:
DASD
Removable DASD
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_FormatUnit
SDLP_LockUnlock
[EXAMPLE]
VAR
Buff : ARRAY[1..2048] of BYTE;
Err,
Res : BYTE;
BEGIN
SDLP_Write( MakeUNum( 0, 4, 0 ),
Addr( Buff ),
2,
4,
Err,
Res );
{ Writes 2 Blocks starting at Block 4 to Target ID 4 }
END;
-*)
Procedure SDLP_Write( UNum : BYTE;
BuffAddr : Pointer;
BlkCount : BYTE;
StartSec : LONGINT;
Var ErrCode : BYTE;
Var Residue : BYTE );
Var
Err : TError;
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
Err := SAL_S2DasdWrite( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
If Err <> sSalxsOK Then
BEGIN
Err := SAL_S2DasdWrite( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
END; { If Err }
If Err <> sSalxsOK Then
BEGIN
Err := SAL_S2DasdWrite( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
StartSec,
BlkCount,
BuffAddr,
0,
NIL );
END; { If Err }
ErrCode := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
R.AH:=3;
R.AL:=Unum;
R.ES:=Seg(BuffAddr^);
R.BX:=Ofs(BuffAddr^);
R.CL:=BlkCount;
R.CH:=StartSec DIV 65536;
R.DX:=StartSec MOD 65536;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
ErrCode:=R.AL;
Residue:=R.CL;
END { If Odd }
ELSE
BEGIN
ErrCode:=0;
Residue:=0;
END; { If Odd / Else }
END; { If UseSAL / Else }
END; { SDLP_Write }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_GetDevInfo( UNum : BYTE;
GetType : BOOLEAN;
GetSize : BOOLEAN;
Var NumBlock : LONGINT;
Var BlkSize : WORD;
Var DevType : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
GetType Whether to Return the Device Type
GetSize Whether to Return the Device Block Size & Count
NumBlock VAR Returned Number of Blocks
BlkSize VAR Returned Block Size
DevType VAR Returned Device Type
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [NumBlock] Number of Blocks)
(VAR : [BlkSize] Block Size)
(VAR : [DevType] Device Type)
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Get Device Size/Type command returning the operation
results. All data is returned in the VARs provided by caller.
Supported Device Types:
DASD
Removable DASD
Sequential
CDROM
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_ReadyUnit
SDLP_FormatUnit
SDLP_LockUnlock
[EXAMPLE]
VAR
Blocks : LONGINT;
BSize : WORD;
DType,
Err : BYTE;
BEGIN
SDLP_GetDevInfo( MakeUNum( 0, 2, 0 ),
TRUE,
TRUE,
Blocks,
BSize,
DType,
Err );
WriteLn( 'Number of Blocks : ', Blocks );
WriteLn( 'Block Size : ', BSize );
Write ( 'Device Type Code : ' );
CASE DType OF
cDASD : WriteLn( 'DASD' );
cRemov : WriteLn( 'Removable DASD' );
cSeq : WriteLn( 'Sequential (Tape)' );
cCDROM : WriteLn( 'CD-ROM' );
cPrint : WriteLn( 'Printer' );
cProc : WriteLn( 'Processor' );
Else WriteLn( 'UnKnown Type' );
END; { Case DType }
WriteLn( 'Error Code : ', Err );
{ Reads Device Information from the Device at Tgt ID 2 }
END;
-*)
Procedure SDLP_GetDevInfo( UNum : BYTE;
GetType : BOOLEAN;
GetSize : BOOLEAN;
Var NumBlock : LONGINT;
Var BlkSize : WORD;
Var DevType : BYTE;
Var ErrCode : BYTE );
Var
Err : TError;
Inq : TInquiry;
Try : BYTE;
LBA : LONGINT;
BlockSize : LONGINT;
R : REGISTERS;
BEGIN
If UseSal Then
BEGIN
ErrCode := 0;
If GetType Then
BEGIN
{-----------------------------}
{ Get the inquiry data, retry }
{ up to 3 times. }
{-----------------------------}
Try := 0;
Repeat
Err := SAL_S2Inquiry( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
0,
36,
@Inq,
0,
NIL );
Inc( Try );
Until ( Err = sSalxsOK ) or ( Try=3 );
ErrCode := ErrorConvert( Err );
{----------------------------------}
{ If everything is ok, we pull the }
{ type out of the inquiry data. }
{ otherwise we return an error. }
{----------------------------------}
If Err = sSalxsOK Then
BEGIN
If (Inq.DevType AND $E0)=0 Then
BEGIN
Case Inq.DevType Of
0 : DevType := Inq.DevType or (Inq.DevModifier AND INQ_Removable);
7 : DevType := 0;
Else
DevType := Inq.DevType;
END; { Case Inq.DevType }
END { If Inq.DevType }
ELSE
BEGIN
{qualifier says no lun here }
ErrCode := 1;
END; { If Inq.DevType }
END { If no error on inquiry }
ELSE
BEGIN { If No Error on Inquiry / Else }
END; { If Inq.DevType / Else }
END; { If GetType }
If (GetSize) and (ErrCode=0) Then
BEGIN
{-------------------------}
{ Read the capacity data. }
{ retry up to 3 times. }
{-------------------------}
Try := 0;
Repeat
Err := SAL_S2DasdReadCapacity( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
0,
NIL,
LBA,
BlockSize );
Inc( Try );
Until ( Err = sSALxsOK ) or ( Try=3 );
ErrCode := ErrorConvert( Err );
{--------------------------}
{ Did we read the capacity }
{ data properly? }
{--------------------------}
If Err = sSALxsOK Then
BEGIN
NumBlock := LBA;
BlkSize := BlockSize;
ErrCode := 0;
END { If Err }
ELSE
BEGIN
ErrCode := ErrorConvert( Err );
END; { If No error on read cap / else }
END; { If GetSize }
END { If UseSAL }
ELSE
BEGIN
R.AH:=5;
R.AL:=UNum;
If GetType Then
BEGIN
If GetSize Then
R.BL:=0
ELSE
R.BL:=1;
END { If GetType }
ELSE
R.BL:=2;
R.SI:=$6A6A;
Intr($11,R);
If NOT Odd( R.FLAGS ) Then
ErrCode := 0
Else
ErrCode := R.AL;
NumBlock:=(R.CH*65536)+R.DX;
BlkSize:=R.AX;
DevType:=R.BL;
END; { If UseSAL / else }
END; { SDLP_GetDevInfo }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_ReadyUnit( Unum : BYTE;
SecsToWait : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
SecToWait Seconds to Retry for if "Not Ready"
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Ready Unit command an returns the operation resutls.
It should be noted that I have not seen the "SecToWait" ever used by
the SDLP function and am not sure that it is supported any more.
Supported Device Types:
DASD
Removable DASD
Sequential
CDROM
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_FormatUnit
SDLP_LockUnlock
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_ReadyUnit( MakeUNum( 0, 0, 0, ),
5,
Err );
{ If Not Ready, Waits at most 5 Seconds before returning Error Code }
END;
-*)
Procedure SDLP_ReadyUnit( Unum : BYTE;
SecsToWait : BYTE;
Var ErrCode : BYTE );
Var
Try : BYTE;
Err : TError;
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
Try := 0;
Repeat
Err := SAL_S2TestUnitReady( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
0,
NIL );
Inc( Try );
If (Err<>sSALxsOK) and (Try<=SecsToWait) Then
{Delay(1000)};
Until ( Try>SecsToWait ) or (Err = sSALxsOK);
ErrCode := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
R.AH:=6;
R.AL:=Unum;
R.BL:=SecsToWait;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_ReadyUnit }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_FormatUnit( Unum : BYTE;
InterLv : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
InterLv Desired Interleave (0=default)
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Format Unit command and returns the operation results.
Supported Device Types:
DASD
Removable DASD
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_LockUnlock
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_Format( MakeUNum( 0, 1, 0 ),
1,
Err );
{ Formats the Device at Target ID 1 with an Interleave of 1 }
END;
-*)
Procedure SDLP_FormatUnit( Unum : BYTE;
InterLv : BYTE;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
END { If UseSAL }
ELSE
BEGIN
R.AH:=7;
R.AL:=Unum;
R.CL:=InterLv;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { if UseSAL / else }
END; { SDLP_FormatUnit }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Rewind( Unum : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Rewind Media command and returns the operation results.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Erase
SDLP_WrFileMark
SDLP_Space
SDLP_LoadUnload
SDLP_Retension
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_Rewind( MakeUNum( 0, 2, 0 ),
Err );
{ Rewinds the Device at Target ID 2 }
END;
-*)
Procedure SDLP_Rewind( Unum : BYTE;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=9;
R.AL:=Unum;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_Rewind }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Erase( Unum : BYTE;
RewFirst : BOOLEAN;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
RewFirst Whether to Rewind First? (NO=Start from Current Position)
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code);
[DESCRIPTION]
Executes an SDLP Erase Media command and returns the operation results.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_WrFileMark
SDLP_Space
SDLP_LoadUnload
SDLP_Retension
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_Erase( MakeUNum( 0, 2, 0 ),
TRUE,
Err );
{ Rewinds the Tape and Erases the Entire Media in the device }
END;
-*)
Procedure SDLP_Erase( Unum : BYTE;
RewFirst : BOOLEAN;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$A;
R.AL:=Unum;
If RewFirst Then
R.CL:=0
Else
R.CL:=1;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / ELSE }
END; { SDLP_Erase }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_WrFileMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
NumMarks Number of Filemarks to Write
ErrCode VAR Returned SDLP Error Code
Residue VAR Returned Number of Unwritten Filemarks
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
(VAR : [Residue] Number of Unwritten Filemarks)
[DESCRIPTION]
Executes an SDLP Write Filemark command and returns the operation error
code.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_Space
SDLP_LoadUnload
SDLP_Retension
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err,
Res : BYTE;
BEGIN
SDLP_WrFileMark( MakeUNum( 0, 2, 0 ),
3,
Err,
Res );
{ Attempts the Write 3 Filemarks to the Tape in the Device }
END;
-*)
Procedure SDLP_WrFileMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$B;
R.AL:=Unum;
R.CL:=NumMarks;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
ErrCode:=R.AL;
Residue:=R.CL;
END { If Odd }
ELSE
BEGIN
ErrCode:=0;
Residue:=0;
END; { If Odd / Else }
END; { If UseSAL / Else }
END; { SDLP_WrSetMark }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Space( Unum : BYTE;
BlksToSpc : LONGINT;
SpaceType : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
BlksToSpc Number of Items to Space
SpaceType Type of Space Item (0=Blocks,1=Filemarks,3=Set Marks)
ErrCode VAR Returned SDLP Error Code
Residue VAR Returned Number of Spaced Items not Executed
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
(VAR : [Residue] Number of Spaced Items not Executed)
[DESCRIPTION]
Executes an SDLP Space command using the given type of space, and
returns the operation error code.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_WrFileMark
SDLP_LoadUnload
SDLP_Retension
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err,
Res : BYTE;
BEGIN
SDLP_Space( MakeUNum( 0, 2, 0 ), 12, 0, Err, Res );
{ Attempts to Space 12 Blocks from Current Position }
SDLP_Space( MakeUNum( 0, 2, 0 ), 6, 1, Err, Res );
{ Attempts to Space 6 Filemarks from Current Position }
SDLP_Space( MakeUNum( 0, 2, 0 ), 4, 3, Err, Res );
{ Attempts to Space 4 Set Marks from Current Position }
END;
-*)
Procedure SDLP_Space( Unum : BYTE;
BlksToSpc : LONGINT;
SpaceType : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$C;
R.AL:=Unum;
R.CH:=BlksToSpc DIV 65536;
R.DX:=BlksToSpc MOD 65536;
R.CL:=SpaceType;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
ErrCode:=R.AL;
Residue:=R.CL;
END { If Odd }
ELSE
BEGIN
ErrCode:=0;
Residue:=0;
END; { If Odd / Else }
END; { If UseSAL / Else }
END; { SDLP_Space }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_LockUnlock( Unum : BYTE;
Lock : BOOLEAN;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
Lock Whether to Lock the Unit (NO=Unlock)
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Lock/Unlock Media command and returns the operation
error code.
Supported Device Types:
Removable DASD
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_FormatUnit
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_LockUnlock( MakeUNum( 0, 1, 0 ),
TRUE,
Err );
{----------------------------------------------------}
{ Device at Target ID 1 should now be Locked. }
{ If Removable DASD or Tape, attempts to Eject Media }
{ will fail. }
{----------------------------------------------------}
END;
-*)
Procedure SDLP_LockUnlock( Unum : BYTE;
Lock : BOOLEAN;
Var ErrCode : BYTE );
Var
R : REGISTERS;
Err : TError;
Try : BYTE;
BEGIN
If UseSAL Then
BEGIN
{ issue test unit readys??? }
Try := 0;
Repeat
If Lock Then
Err := SAL_S2DasdLockMedia( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
0,
NIL )
Else
Err := SAL_S2DasdUnLockMedia( SDLPSalHandle,
GetBus( UNum ),
GetTar( UNum ),
GetLun( UNum ),
0,
0,
NIL );
Inc( Try );
Until (Try=3) or (Err=sSALxsOK);
ErrCode := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
R.AH:=$D;
R.AL:=Unum;
If Lock Then
R.CL:=1
Else
R.CL:=0;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_LockUnlock }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_LoadUnload( Unum : BYTE;
Load : BOOLEAN;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
Load Whether operation is a Load (NO=Unload)
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Load/Unload Media command and returns the operation
error code.
Supported Device Types:
Removable DASD
Sequential
CDROM
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_WrFileMark
SDLP_Space
SDLP_Retension
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
WriteLn( 'Please Insert Cartridge in Drive Tgt 1' );
WriteLn( 'and Press <ENTER> to Load...' );
While ReadKey <> #13 Do;
SDLP_Load( MakeUNum( 0, 1, 0 ),
TRUE,
Err );
WriteLn( 'Press <ENTER> to Eject Cartridge in Drive Tgt 1' );
While ReadKey <> #13 Do;
SDLP_Load( MakeUNum( 0, 1, 0 ),
FALSE,
Err );
WriteLn( 'Done' );
END;
-*)
Procedure SDLP_LoadUnload( Unum : BYTE;
Load : BOOLEAN;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$E;
R.AL:=Unum;
If Load Then
R.CL:=1
Else
R.CL:=0;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_LoadUnload }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_Retension( Unum : BYTE;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP Retension Media command on the selected device and
return the operation error code.
NOTE: Re-Tension as in "to redo the tape tension" as opposed to
"to retain" - if you are having trouble with this, it may not be
advisable to fool around with this.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_WrFileMark
SDLP_Space
SDLP_LoadUnload
SDLP_SetBlockSize
SDLP_WrSetMark
[EXAMPLE]
VAR
Err : BYTE;
BEGIN
SDLP_Retension( MakeUNum( 0, 2, 0 ),
Err );
{ Tape in Device at Target ID 2 has been Retensioned }
END;
-*)
Procedure SDLP_Retension( Unum : BYTE;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$E;
R.AL:=Unum;
R.CL:=3;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_Retension }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_SetBlockSize( Unum : BYTE;
BlockSize : WORD;
Var ErrCode : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
BlockSize Desired Block Size
ErrCode VAR Returned SDLP Error Code
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
[DESCRIPTION]
Executes an SDLP SetBlockSize command and returns the operation results.
BlockSizes are Generally Binary Powers of 512 (ie. 512, 1024, 2048, 4096,
8192, 16384, and 32768).
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_WrFileMark
SDLP_Space
SDLP_LoadUnload
SDLP_Retension
SDLP_WrSetMark
[EXAMPLE]
VAR
Err : BYTE;
i : INTEGER;
BEGIN
For i := 6 DownTo 0 Do
BEGIN
SDLP_SetBlockSize( MakeUNum( 0, 2, 0 ),
512 SHL i,
Err );
WriteLn( 'Set Block Size to ',512 SHL i:5,', Error Code was ', Err );
END; { For i }
{ Attempts Different Block Sizes and Reports the Results }
END;
-*)
Procedure SDLP_SetBlockSize( Unum : BYTE;
BlockSize : WORD;
Var ErrCode : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$10;
R.AL:=Unum;
R.BX:=BlockSize;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
ErrCode:=R.AL
ELSE
ErrCode:=0;
END; { If UseSAL / Else }
END; { SDLP_SetBlockSize }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_WrSetMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
[PARAMETERS]
UNum SDLP Unit Number
NumMarks Number of Set Marks to Write
ErrCode VAR Returned SDLP Error Code
Residue VAR Returned Number of Unwritten Set Marks
[RETURNS]
Function : None
(VAR : [ErrCode] SDLP Error Code)
(VAR : [Residue] Number of Unwritten Set Marks)
[DESCRIPTION]
Executes a Write Set Mark command on the unit selected and returns the
operation results.
Supported Device Types:
Sequential
[SEE-ALSO]
SDLP_Read
SDLP_Write
SDLP_GetDevInfo
SDLP_ReadyUnit
SDLP_Rewind
SDLP_Erase
SDLP_WrFileMark
SDLP_Space
SDLP_LoadUnload
SDLP_Retension
SDLP_SetBlockSize
[EXAMPLE]
VAR
Err,
Res : BYTE;
BEGIN
SDLP_WrSetMark( MakeUNum( 0, 2, 0 ),
4,
Err,
Res );
{ Attempts to Write 4 Set Marks on Media in Device at Target ID 2 }
END;
-*)
Procedure SDLP_WrSetMark( Unum : BYTE;
NumMarks : BYTE;
Var ErrCode : BYTE;
Var Residue : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ErrCode := 1;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$11;
R.AL:=Unum;
R.CL:=NumMarks;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
ErrCode:=R.AL;
Residue:=R.CL;
END { If Odd }
ELSE
BEGIN
ErrCode:=0;
Residue:=0;
END; { If Odd / Else }
END; { If UseSAL / Else }
END; { SDLP_WrSetMark }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_SetSCSIXHac( HAC : INTEGER );
[PARAMETERS]
HAC Desired Host Adapter Number
[RETURNS]
(None)
[DESCRIPTION]
Changes the active Host adapter channnel to the one selected. All IO
now goest thru this channel. (NOTE: for compatibility, all HACs must
be returned to Zero (0) after use)
[SEE-ALSO]
SDLP_GetSCSIXHac
[EXAMPLE]
VAR
HAC,
Err : BYTE;
BEGIN
SDLP_SetSCSIXHac( 1 );
SDLP_GetSCSIXHac( HAC, Err );
WriteLn( 'The Current Active HAC is ',HAC )
SDLP_SetSCSIXHac( 0 );
SDLP_GetSCSIXHac( HAC, Err );
WriteLn( 'The Current Active HAC is ',HAC )
END;
-*)
Procedure SDLP_SetSCSIXHac( HAC : INTEGER );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
ExecSCSIHac := HAC;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$FE;
R.AL:=HAC;
R.CL:=1;
R.SI:=$6A6A;
Intr($11,R);
END; { IF UseSAL / Else }
END; { SDLP_SetSCSIXHac }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Procedure SDLP_GetSCSIXHac( Var Hac : INTEGER;
Var Err : BYTE );
[PARAMETERS]
HAC VAR Returned Current HAC
Err VAR Returned Error Code
[RETURNS]
Function : None
(VAR : [HAC] Current HAC)
(VAR : [Err] Error Code)
[DESCRIPTION]
Returns the currently active Host adapter channnel number.
[SEE-ALSO]
SDLP_SetSCSIXHac
[EXAMPLE]
VAR
HAC,
Err : BYTE;
BEGIN
SDLP_GetSCSIXHac( HAC, Err );
If Err = 0 Then
WriteLn( 'The Current Active HAC is ',HAC )
Else
WriteLn( 'Error Occured' );
END;
-*)
Procedure SDLP_GetSCSIXHac( Var Hac : INTEGER;
Var Err : BYTE );
Var
R : REGISTERS;
BEGIN
If UseSAL Then
BEGIN
Hac := ExecSCSIHac;
Err := 0;
END { If UseSAL }
ELSE
BEGIN
R.AH:=$FE;
R.CL:=$0;
R.SI:=$6A6A;
Intr($11,R);
If Odd(R.FLAGS) Then
BEGIN
Err:=R.AL;
END { If Odd }
ELSE
BEGIN
Err:=0;
Hac:=R.AL;
END; { If Odd / Else }
END; { If UseSAL / else }
END; { SDLP_GetSCSIXHac }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function OutSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ):WORD;
[PARAMETERS]
SUnit SCSI Unit Number
CDB Pointer to CDB Data
Buff Pointer to Data Buffer
CDBLen CDB Length in Bytes
BytesToIO Data Buffer Length in Bytes
[RETURNS]
SCSI Execution Error Code ($0000 = No Error)
($xx.. = HAC Error Code)
($..xx = Device Error Code)
[DESCRIPTION]
This executes a SDLP Passthru Write to the selected device using the
provided CDB and Data.
This SCSI Operation is an OutFlow (Write) Operation. All Buffer data
is going out from the Caller rather than InFlowing to the Caller.
Supported Device Types:
ALL!
[SEE-ALSO]
InSCSI
InSCSI_ReqSense
[EXAMPLE]
VAR
CDB : ARRAY[0..5] of BYTE;
Buff : ARRAY[1..512] of BYTE;
Err : WORD;
BEGIN
FillChar( CDB, SizeOf( CDB ), 0 );
CDB[0] := $28; { Write }
CDB[3] := 5; { Block }
CDB[4] := 1; { Count }
Err := OutSCSI( MakeUNum( 0, 0, 0 ),
Addr( CDB ),
Addr( Buff ),
6,
512 );
{-----------------------------------------------------------}
{ Command to Write 1 Block of 512 bytes starting at Block 5 }
{ on the Device at Target ID 0 }
{-----------------------------------------------------------}
END;
-*)
Function OutSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ):WORD;
Var
R : REGISTERS;
Err : TError;
BEGIN
If UseSAL Then
BEGIN
Err := SAL_ExecSCSI( SDLPSalHandle,
cSALxsWrite,
GetBus( SUnit ),
GetTar( SUnit ),
GetLun( SUnit ),
CDBLen,
CDB,
BytesToIo,
Buff,
0,
NIL );
OutSCSI := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
SDLP_SetSCSIxHac(SUNIT DIV 64);
R.AH:=$FF;
R.AL:=(SUnit MOD 64) OR 128;
R.DS:=Seg(CDB^);
R.DI:=Ofs(CDB^);
R.ES:=Seg(Buff^);
R.BX:=Ofs(Buff^);
R.DH:=BytesToIO DIV 65536;
R.CX:=BytesToIO MOD 65536;
R.DL:=CDBLen;
R.SI:=$6A6A;
Intr($11,R);
SDLP_SetSCSIxHAC(0);
If Odd(R.FLAGS)=FALSE Then
OutSCSI:=0
ELSE
OutSCSI:=R.AX;
END; { If UseSAL / else }
END; { OutSCSI }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function InSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ):WORD;
[PARAMETERS]
SUnit SCSI Unit Number
CDB Pointer to CDB Data
Buff Pointer to Data Buffer
CDBLen CDB Length in Bytes
BytesToIO Buffer Length in Bytes
[RETURNS]
SCSI Execution Error Code ($0000 = No Error)
($xx.. = HAC Error Code)
($..xx = Device Error Code)
[DESCRIPTION]
This executes a SDLP Passthru Read to the selected device using the
provided CDB and Data.
This SCSI Operation is an InFlow (Read) Operation. All Buffer data
is coming back to the Caller rather than OutFlowing from the Caller.
Supported Device Types:
ALL!
[SEE-ALSO]
OutSCSI
InSCSI_ReqSense
[EXAMPLE]
VAR
CDB : ARRAY[0..5] of BYTE;
Buff : ARRAY[1..512] of BYTE;
Err : WORD;
BEGIN
FillChar( CDB, SizeOf( CDB ), 0 );
CDB[0] := $08; { Read }
CDB[3] := 5; { Block }
CDB[4] := 1; { Count }
Err := InSCSI( MakeUNum( 0, 0, 0 ),
Addr( CDB ),
Addr( Buff ),
6,
512 );
{----------------------------------------------------------}
{ Command to Read 1 Block of 512 bytes starting at Block 5 }
{ on the Device at Target ID 0 }
{----------------------------------------------------------}
END;
-*)
Function InSCSI( SUnit : BYTE;
CDB : Pointer;
Buff : Pointer;
CDBLen : BYTE;
BytesToIO : LONGINT ):WORD;
Var
R : REGISTERS;
Err : TError;
BEGIN
If UseSAL Then
BEGIN
Err := SAL_ExecSCSI( SDLPSalHandle,
cSALxsRead,
GetBus( SUnit ),
GetTar( SUnit ),
GetLun( SUnit ),
CDBLen,
CDB,
BytesToIo,
Buff,
0,
NIL );
InSCSI := ErrorConvert( Err );
END { If UseSAL }
ELSE
BEGIN
SDLP_SetSCSIxHAC(SUnit DIV 64);
R.AH:=$FF;
R.AL:=(SUnit MOD 64);
R.DS:=Seg(CDB^);
R.DI:=Ofs(CDB^);
R.ES:=Seg(Buff^);
R.BX:=Ofs(Buff^);
R.DH:=BytesToIO DIV 65536;
R.CX:=BytesToIO MOD 65536;
R.DL:=CDBLen;
R.SI:=$6A6A;
Intr($11,R);
SDLP_SetSCSIxHAC(0);
If Odd(R.FLAGS)=FALSE Then
InSCSI:=0
ELSE
InSCSI:=R.AX;
END; { If UseSAL / Else }
END; { InSCSI }
{────────────────────────────────────────────────────────────────────────────}
(*-
[FUNCTION]
Function InSCSI_ReqSense ( SUnit : BYTE;
Buff : Pointer;
ReqSenseLen : BYTE ):WORD;
[PARAMETERS]
SUnit SCSI Unit Number
Buff Pointer to Data Buffer
ReqSenseLen Number of Bytes to Return in Data Buffer
[RETURNS]
SCSI Error Code ($00 = Successful)
[DESCRIPTION]
This executes a Request Sense and returns the data and execution results
This Operation is NOT Restricted to just Request Senses on InSCSI
Operations but for all SCSI Operations. SDLP Operations Automatically
take care of this as part of their normal functioning (vital information
being the SDLP Error Code).
Supported Device Types:
ALL!
[SEE-ALSO]
OutSCSI
InSCSI
[EXAMPLE]
VAR
Buff : ARRAY[1..64] of BYTE;
BEGIN
InSCSI_ReqSense( MakeUNum( 0, 0, 0 ),
Addr( Buff ),
32 );
For i := 1 to 64 Do
Write( Buff[i]:3 );
WriteLn;
{-------------------------------------------------------}
{ Reads the Request Sense Data on Device in Target ID 0 }
{ and displays it. }
{-------------------------------------------------------}
END;
-*)
Function InSCSI_ReqSense ( SUnit : BYTE;
Buff : Pointer;
ReqSenseLen : BYTE ):WORD;
Var
R : REGISTERS;
CDB : Array[0..5] of BYTE;
BEGIN
CDB[0] := $03;
CDB[1] := (SUnit AND 7) SHL 5;
CDB[2] := 0;
CDB[3] := 0;
CDB[4] := ReqSenseLen;
CDB[5] := 0;
InSCSI_ReqSense := InSCSI( Sunit, Addr(CDB), Buff, 6, ReqSenseLen );
END; { InSCSI_ReqSense }
{────────────────────────────────────────────────────────────────────────────}
{────────────────────────────────────────────────────────────────────────────}
{────────────────────────────────────────────────────────────────────────────}
BEGIN
UseSAL := FALSE;
ExecSCSIHac := 0;
SDLPMethod := SL_UseSDLP;
END.